package com.gzsxy.sso.core.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.gzsxy.sso.core.entity.Role;
import com.gzsxy.sso.core.entity.UserRole;
import com.gzsxy.sso.core.dao.UserRoleMapper;
import com.gzsxy.sso.core.model.SessionUser;
import com.gzsxy.sso.core.service.UserRoleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gzsxy.sso.core.utils.SessionUserUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author zxl
 * @since 2021-11-10
 */
@Service
public class UserRoleServiceImpl extends ServiceImpl<UserRoleMapper, UserRole> implements UserRoleService {

    private final static Logger log =  LoggerFactory.getLogger(UserRoleServiceImpl.class);


    @Autowired
    private UserRoleMapper userRoleMapper;



    /**
     * @description: 根据用户id添加角色列表
     * @param
     * @return
     */
    @Transactional(rollbackFor = Exception.class) //添加事务配置 异常回滚
    @Override
    public void addRoleByuserId(String userId, String roleIds) {

        //将角色id分割（多个角色）
        List<String> roleIdList = Arrays.asList(roleIds.split(","))
                //去除空字符串
                .stream().filter(str-> !str.isEmpty()).collect(Collectors.toList());
        //查询用户下所有的角色
        LambdaQueryWrapper<UserRole> wrapper1 = Wrappers.lambdaQuery();
        wrapper1.eq(UserRole::getUserId,userId);
        List<UserRole> userRoles = userRoleMapper.selectList(wrapper1);
        //1.第一种方式
//        //过滤获取实体类中角色id的列表数据 (当前用户总的角色id)
//        List<String> roles = userRoles.stream().map(UserRole::getRoleId).collect(Collectors.toList());
//        //为了筛选出用户已有角色id不在传值进来的角色id中的id（用户有1，2，3；传值1，2，执行完3）
//        for (int i = 0; i < roleIdList.size(); i++) {
//            for (int j = 0; j <roles.size(); j++) {
//                //当用户角色id已有
//                if (roleIdList.get(i).equals(roles.get(j))){
//                    //移除掉已有的id
//                    roles.remove(roles.get(j));
//                }
//            }
//        }
//
//        //当前用户多余的角色id（业务需求是但用户选中几个角色，就传值几个角色的id，最后同步角色id数量）
//        if (roles.size() !=0){
//            //删除多余的角色id
//            for (int i = 0; i < roles.size(); i++) {
//                LambdaQueryWrapper<UserRole> wrapper = Wrappers.lambdaQuery();
//                wrapper.eq(UserRole::getRoleId,roles.get(i));
//                wrapper.eq(UserRole::getUserId,userId);
//                userRoleMapper.delete(wrapper);
//            }
//        } else {
//            //获取当前用户
//            SessionUser sessionUser = SessionUserUtil.getSessionUser();
//            for (String roleid : roleIdList) {
//                //筛除该用户下已有的角色
//                LambdaQueryWrapper<UserRole> wrapper = Wrappers.lambdaQuery();
//                wrapper.eq(UserRole::getUserId,userId);
//                wrapper.eq(UserRole::getRoleId,roleid);
//                UserRole userRole1 = userRoleMapper.selectOne(wrapper);
//                if (!ObjectUtils.isEmpty(userRole1)){
//                    log.info("用户id为{}下已有角色id{}",userId,roleid);
//                    continue;
//                }
//                //添加角色
//                UserRole userRole = new UserRole();
//                userRole.setRoleId(roleid);
//                userRole.setUserId(userId);
//                userRole.setAddUser(sessionUser.getUserName());
//                userRole.setUpdateUser(sessionUser.getUserName());
//                userRoleMapper.insert(userRole);
//            }
//        }

        //2.第二种方式（性能提高）
        List<UserRole> addList = new ArrayList<>();
        //获取原有角色列表转为map对象
        Map<String, UserRole> map = userRoles.stream().collect(Collectors.toMap(UserRole::getRoleId, o -> o));

        if (CollectionUtils.isNotEmpty(roleIdList)){
            for (String roleId : roleIdList) {
                //原角色列表中存在当前传入的角色id
                if (map.containsKey(roleId)){
                    //删除map对象中存在的元素
                    map.remove(roleId);
                } else {
                    //获取当前用户
//                    SessionUser sessionUser = SessionUserUtil.getSessionUser();
                    UserRole userRole = new UserRole();
                    userRole.setRoleId(roleId);
                    userRole.setUserId(userId);
//                    userRole.setAddUser(sessionUser.getUserName());
//                    userRole.setUpdateUser(sessionUser.getUserName());
                    addList.add(userRole);
                }
            }
        }
        //获取需要删除的id集合
        List<String> deleteIdList = map.values().stream().map(UserRole::getId).collect(Collectors.toList());
        //批量删除
        if (CollectionUtils.isNotEmpty(deleteIdList)){
            baseMapper.deleteBatchIds(deleteIdList);
        }
        //批量添加
        if (CollectionUtils.isNotEmpty(addList)){
            this.saveBatch(addList);
        }
    }



    /**
     * @description: 通过用户id查询对应的所有角色
     * @param userId 用户id
     * @return
     */
    @Override
    public List<Role> findRolesByUserId(String userId) {
        return userRoleMapper.findRolesByUserId(userId);
    }
}
